package com.distribute.core.core;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 本地缓存 骨架类 ，继承此方法，可以项目启动，自动执行 缓存初始化方法
 *
 * @author chennengcheng
 * @date 2021-09-17 16:52
 * @remark
 */
public abstract class BaseCacheManageCell<T extends BaseNotifyMessage> {

    private static final Logger log = LoggerFactory.getLogger(BaseCacheManageCell.class);

    /**
     * 所属模块名 前缀
     */
    public String modelPrefix;

    /**
     * 所属模块名
     */
    public String model;

    /**
     * 缓存开启状态 true:开启(默认) false:关闭
     */
    public AtomicBoolean status = new AtomicBoolean(true);

    /**
     * 缓存操作类名
     */
    public String cacheClassSimpleName;

    public AtomicBoolean getStatus() {
        return status;
    }

    public void setStatus(Boolean status) {
        this.status.set(status);
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getModelPrefix() {
        return modelPrefix;
    }

    public void setModelPrefix(String modelPrefix) {
        this.modelPrefix = modelPrefix;
    }

    public String getCacheClassSimpleName() {
        return cacheClassSimpleName;
    }

    public void setCacheClassSimpleName(String cacheClassSimpleName) {
        this.cacheClassSimpleName = cacheClassSimpleName;
    }

    /**
     * 初始化缓存
     * @return 初始化条数
     */
    public int init() {
        int size = initCache();
        log.info("开始初始化本地缓存 modelPrefix: {} model: {}  Class: {}.class  status: {} size: {}条",
                getModelPrefix(), getModel(), getCacheClassSimpleName(), getStatus(), size);
        return size;
    }

    /**
     * 开始初始化缓存
     * @return
     */
    public abstract int initCache();

    /**
     * 刷新缓存
     * @return 刷新条数
     */
    protected abstract int flush(T notifyMessage);

    /**
     * 刷新所有缓存数据
     * @return
     */
    protected abstract int flushAll();


    /**
     * 关闭缓存
     * @return
     */
    public void closeCache(){
        log.info("缓存关闭：" + modelPrefix + StrUtil.COLON + model);
        if (status.get()){
            setStatus(false);
        }

    }


    /**
     * 开启缓存
     * @return
     */
    public void openCache() {
        log.info("缓存打开：" + modelPrefix + StrUtil.COLON + model);
        if (status.get()){
            return;
        }

        setStatus(true);
    }

    /**
     * 刷新全量缓存数据
     * @return
     */
    public int flushAllData() {
        try {
            return flushAll();
        }catch (Exception e) {
            log.error("刷新全量缓存数据失败，请检查：" + JSONUtil.toJsonStr(e));
        }

        return 0;
    }

    /**
     * 刷新数据
     * @param notifyMessage
     * @return
     */
    public int flushData(T notifyMessage) {
        try {
            return flush(notifyMessage);
        }catch (Exception e) {
            log.error("刷新缓存数据失败，请检查：" + JSONUtil.toJsonStr(e));
        }

        return 0;
    }

    /**
     * 获取缓存数量
     * @return
     */
    public abstract int size();

    /**
     * 获取缓存数据JSON信息
     * @return
     */
    public abstract String getCacheDataJson();
}
